class KeStorage {
  constructor (type) {
    if (type === 'local') {
      this.storage = localStorage
    } else {
      this.storage = sessionStorage
    }
  }

  /**
   * 获取整数
   * @param key
   * @returns {number}
   */
  getInteger(key) {
    return parseInt(this.storage.getItem(key))
  }

  /**
   * 获取浮点数
   * @param key
   * @returns {float}
   */
  getFloat(key) {
    return parseFloat(this.storage.getItem(key))
  }

  /**
   * 获取布尔值
   * @param key
   * @returns {boolean}
   */
  getBoolean(key) {
    return !!parseInt(this.storage.getItem(key))
  }

  /**
   * 获取字符串
   * @param key
   * @returns {string}
   */
  getString(key) {
    return this.storage.getItem(key)
  }

  /**
   * 获取字符串
   * @param key
   */
  getJson(key) {
    let tmp = JSON.parse(this.storage.getItem(key))
    if (tmp) {
      return tmp
    } else {
      return null
    }
  }

  /**
   * 保存整数
   * @param key
   * @param value
   */
  setInteger(key, value) {
    return this.storage.setItem(key, value)
  }

  /**
   * 保存字符串
   * @param key
   * @param value
   */
  setString(key, value) {
    return this.storage.setItem(key, value)
  }

  /**
   * 保存浮点数
   * @param key
   * @param value
   */
  setFloat(key, value) {
    return this.storage.setItem(key, value)
  }

  /**
   * 保存布尔值
   * @param key
   * @param value
   */
  setBoolean(key, value) {
    return this.storage.setItem(key, value)
  }

  /**
   * 保存json
   * @param key
   * @param value
   */
  setJson(key, value) {
    return this.storage.setItem(key, JSON.stringify(value))
  }

  /**
   * 删除节点
   * @param key
   */
  remove(key) {
    this.storage.removeItem(key)
  }
}

/**
 * 数组类
 */
class KeArray {
  /**
   * 更新数组，自动合并
   * @param {array} arr 数组
   * @param {mixed} key 主键
   * @param {object} columns 更新的字段
   * @param {string} keyName 主键名
   */
  update (arr, key, columns, keyName = 'id') {
    const idx = arr.findIndex(item => item[keyName] === key)
    if (idx > -1) {
      arr.splice(idx, 1, {
        ...arr[idx],
        ...columns
      })
    }
  }

  /**
   * 树形结构
   * @param arr
   * @param id
   * @param pid
   * @param children
   * @returns {[]}
   */
  tree (arr, id = 'id', pid = 'pid', children = 'children') {
    let map = {}
    for (let i = 0; i < arr.length; i++) {
      map[arr[i][id]] = arr[i]
    }
    let newArray = []
    const f = () => {
      for (let i = 0; i < arr.length; i++) {
        let parent = map[arr[i][pid]]
        if (parent) {
          (parent[children] || (parent[children] = [])).push(arr[i])
        } else {
          newArray.push(arr[i])
        }
      }
    }
    f()
    return newArray
  }

  /**
   * 数组去重
   * @param arr
   * @returns {*}
   */
  unique(arr) {
    const res = new Map()
    return arr.filter((a) => !res.has(a) && res.set(a, 1))
  }
}

window.KE = new class {
  constructor () {
    this._events = {
      'page-active': [], // 页面激活事件
    }
    // 不同浏览器 hidden 名称
    const hiddenProperty = 'hidden' in document ? 'hidden' :
      'webkitHidden' in document ? 'webkitHidden' :
        'mozHidden' in document ? 'mozHidden' :
          null
    // 不同浏览器的事件名
    const visibilityChangeEvent = hiddenProperty.replace(/hidden/i, 'visibilitychange')
    document.addEventListener(visibilityChangeEvent, () => {
      if (!document[hiddenProperty]) {
        this._events['page-active'].map(v => v())
      }
    })
  }

  // 当前时间戳
  timestamp(millisecond = false) {
    const time = new Date().getTime()
    if (!millisecond) {
      return Math.ceil(time / 1000)
    }
    return time
  }

  //生成从minNum到maxNum的随机数
  randomNum(minNum,maxNum){
    return parseInt(Math.random() * (maxNum - minNum + 1) + minNum, 10)
  }

  // 事件监听
  event(type, callback) {
    this._events[type].push(callback)
  }

  // 本地存储类
  get localStorage() {
    return new KeStorage('local')
  }

  // 本地存储类
  get sessionStorage() {
    return new KeStorage('session')
  }

  // jwt信息获取
  jwtInfoGet (str) {
    try {
      let tmp = str.split('.')
      let info = JSON.parse(atob(tmp[0]))
      return [info, parseInt(tmp[1]), tmp[2]]
    } catch (e) {
      return null
    }
  }

  // 判断变量是否为空
  isEmpty (data) {
    return data === undefined || data === null || data === 0
  }

  // 判断变量是否被设置
  isIsset (data) {
    return data !== undefined
  }

  // 强制转为整数
  intval (data) {
    let val = parseInt(data)
    return isNaN(val) ? 0 : val
  }

  // 数组方法
  get array() {
    return new KeArray()
  }

  // 生成element表单必填的验证规则
  validateRule (rules) {
    let map = {}
    rules.map((item) => {
      map[item[0]] = [
        { required: true, message: `${item[1]}` }
      ]
    })
    return map
  }
}

